import re
import datetime
from django.template.defaultfilters import slugify
from django.db.models import SlugField, SubfieldBase
from south.modelsinspector import add_introspection_rules

class AutoSlugField(SlugField):
    """ AutoSlugField

    By default, sets editable=False, blank=True.

    Required arguments:

    populate_from
        Specifies which field or list of fields the slug is populated from.

    Optional arguments:

    separator
        Defines the used separator (default: '-')

    overwrite
        If set to True, overwrites the slug on every save (default: False)

    recursive
        If set, track callable/field recursively and prepend to slug
    
    use_recursive_slug
        If set, when recursive is enabled it will prepend only slug from first recursive item
    
    prefix_from
        If set, prepend to slug

    Based on django-extensions, inspired by SmileyChris' Unique Slugify snippet:
    http://www.djangosnippets.org/snippets/690/
    """

    __metaclass__ = SubfieldBase

    def __init__(self, *args, **kwargs):
        kwargs.setdefault('blank', True)
        kwargs.setdefault('editable', False)

        populate_from = kwargs.pop('populate_from', None)
        if populate_from is None:
            raise ValueError("missing 'populate_from' argument")
        else:
            self._populate_from = populate_from
        self.field_separator = kwargs.pop('field_separator',  u'/')
        self.separator = kwargs.pop('separator',  u'-')
        self.overwrite = kwargs.pop('overwrite', False)
        self.recursive = kwargs.pop('recursive', False)
        self.use_recursive_slug = kwargs.pop('use_recursive_slug', False)
        self.prefix_from = kwargs.pop('prefix_from', False)
        super(AutoSlugField, self).__init__(*args, **kwargs)

    def _slug_strip(self, value):
        """
        Cleans up a slug by removing slug separator characters that occur at
        the beginning or end of a slug.

        If an alternate separator is used, it will also replace any instances
        of the default '-' separator with the new separator.
        """
        re_sep = '(?:-|%s)' % re.escape(self.separator)
        value = re.sub('%s+' % re_sep, self.separator, value)
        return re.sub(r'^%s+|%s+$' % (re_sep, re_sep), '', value)

    def slugify_func(self, content):
        try:
            from pytils.translit import translify
            content = translify(content)
        except:
            pass

        return slugify(content)

    def get_recursive_model(self, current_model):
        pass

    def create_slug(self, model_instance, add):
        # get fields to populate from and slug field to set
        if not isinstance(self._populate_from, (list, tuple)):
            self._populate_from = (self._populate_from, )
        slug_field = model_instance._meta.get_field(self.attname)

        if add or self.overwrite:
            # slugify the original field content and set next step to 2
            if self.recursive:
                L = []
                tmp = model_instance
                while tmp:
                    slug_for_field = lambda field: self.slugify_func(getattr(tmp, field))
                    L.append(self.separator.join(map(slug_for_field, self._populate_from)))
                    tmp = getattr(tmp, self.recursive)
                    if callable(tmp):
                        tmp = tmp()

                    if self.use_recursive_slug and tmp != None:
                        L.append(getattr(tmp, 'slug'))
                        break

                L.reverse()
                slug = self.field_separator.join(L)
            else:
                slug_for_field = lambda field: self.slugify_func(getattr(model_instance, field))
                slug = self.separator.join(map(slug_for_field, self._populate_from))

            if self.prefix_from:
                prefix = self.slugify_func(getattr(model_instance, self.prefix_from[0]))
                slug = "%s%s%s" % (prefix, self.field_separator, slug)

            next = 2
        else:
            # get slug from the current model instance and calculate next
            # step from its number, clean-up
            slug = self._slug_strip(getattr(model_instance, self.attname))
            next = slug.split(self.separator)[-1]
            if next.isdigit():
                slug = self.separator.join(slug.split(self.separator)[:-1])
                next = int(next)
            else:
                next = 2

        # strip slug depending on max_length attribute of the slug field
        # and clean-up
        slug_len = slug_field.max_length
        if slug_len:
            slug = slug[:slug_len]
        slug = self._slug_strip(slug)
        original_slug = slug

        # exclude the current model instance from the queryset used in finding
        # the next valid slug
        queryset = model_instance.__class__._default_manager.all()
        if model_instance.pk:
            queryset = queryset.exclude(pk=model_instance.pk)

        # form a kwarg dict used to impliment any unique_together contraints
        kwargs = {}
        for params in model_instance._meta.unique_together:
            if self.attname in params:
                for param in params:
                    kwargs[param] = getattr(model_instance, param, None)
        kwargs[self.attname] = slug

        # increases the number while searching for the next valid slug
        # depending on the given slug, clean-up
        while not slug or queryset.filter(**kwargs):
            slug = original_slug
            end = '%s%s' % (self.separator, next)
            end_len = len(end)
            if slug_len and len(slug)+end_len > slug_len:
                slug = slug[:slug_len-end_len]
                slug = self._slug_strip(slug)
            slug = '%s%s' % (slug, end)
            kwargs[self.attname] = slug
            next += 1
        if slug.startswith('-') and slug[1:].isdigit():
            slug = model_instance.__class__.__name__.lower() + slug
        return slug

    def pre_save(self, model_instance, add):
        value = unicode(self.create_slug(model_instance, add))
        setattr(model_instance, self.attname, value)
        return value

    def get_internal_type(self):
        return "SlugField"

add_introspection_rules(
    [(
        [AutoSlugField],
        [],
        {'populate_from': ["_populate_from", {}], 'recursive': ["recursive", {}]}
    )],
    ["^django_autoslug\.fields\.AutoSlugField"]
)
